home *** CD-ROM | disk | FTP | other *** search
/ Mac Power 1997 January / macpower199701.bin / AMUG / Programming_10 / WASTE 1.3a1.sit / WASTE 1.3a1 Distribution / Extras / Minimal IC APIs / ICCFMGlue.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-23  |  28.9 KB  |  1,221 lines  |  [TEXT/CWIE]
  1. /* ･･･Start Header･･･ */
  2.  
  3. /* File:         PPC_ICAPI.c
  4.  * Generated by: 1.0d4
  5.  * For:          IC 1.2
  6.  * On:           Monday, 25 September 1995, 19:28:12
  7.  * 
  8.  * This file is part of the Internet Configuration system and
  9.  * is placed in the public domain for the benefit of all.
  10.  */
  11.  
  12. /* ･･･End Header･･･ */
  13.  
  14. #include <Types.h>
  15. #include <MixedMode.h>
  16. #include <Components.h>
  17.  
  18. #include "ICTypes.h"
  19. #include "ICAPI.h"
  20. // #include "ICCAPI.h"
  21.  
  22. #pragma options align=mac68k
  23.  
  24. enum {
  25.     internetConfigurationComponentType = 'PREF',                            /* the component type */
  26.     internetConfigurationComponentSubType = 'ICAp'                      /* the component subtype */
  27. };
  28.  
  29. enum {
  30.   uppCallComponentProcInfo = kPascalStackBased
  31.     | RESULT_SIZE(kFourByteCode)
  32.     | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  33. };
  34.  
  35. pascal ICError ICStart(ICInstance *inst, OSType creator)
  36. {
  37.   ICError junk;
  38.   ICError err;
  39.   long response;
  40.   struct {
  41.     char param_flags;
  42.     char param_size;
  43.     short param_what;
  44.     OSType creator;
  45.     ICInstance inst;
  46.   } params;
  47.   
  48.   *inst = nil;
  49.   if (Gestalt(gestaltComponentMgr, &response) == noErr) {
  50.     *inst = (ICInstance) OpenDefaultComponent(internetConfigurationComponentType, internetConfigurationComponentSubType);
  51.   };
  52.   if (*inst == nil) {
  53.     err = badComponentInstance;
  54.   } else {
  55.     params.param_flags = 0;
  56.     params.param_size = 4;
  57.     params.param_what = 0x00;
  58.     params.creator = creator;
  59.     params.inst = *inst;
  60.     err = CallUniversalProc(CallComponentUPP, uppCallComponentProcInfo, ¶ms);
  61.     if (err != noErr) {
  62.       junk = CloseComponent((ComponentInstance) *inst);
  63.       *inst = nil;
  64.     };
  65.   };
  66.   return(err);
  67. }
  68.  
  69. pascal ICError ICCStart(ICInstance *inst, OSType creator)
  70. {
  71.     return (ICStart(inst, creator));
  72. }
  73.  
  74. pascal ICError ICStop(ICInstance inst)
  75. {
  76.   ICError err;
  77.   ICError err2;
  78.   struct {
  79.     char param_flags;
  80.     char param_size;
  81.     short param_what;
  82.     ICInstance inst;
  83.   } params;
  84.   
  85.   params.param_flags = 0;
  86.   params.param_size = 0;
  87.   params.param_what = 0x01;
  88.   params.inst = inst;
  89.   err = CallUniversalProc(CallComponentUPP, uppCallComponentProcInfo, ¶ms);
  90.   err2 = CloseComponent((ComponentInstance) inst);
  91.   if (err == noErr) {
  92.     err = err2;
  93.   };
  94.   return(err);
  95. }
  96.  
  97. pascal ICError ICCStop(ICInstance inst)
  98. {
  99.     return (ICStop(inst));
  100. }
  101.  
  102. pascal ICError ICGetComponentInstance(ICInstance inst, Ptr *component_inst)
  103. {
  104.     *component_inst = inst;
  105.     return (noErr);
  106. }
  107.  
  108. pascal ICError ICCGetComponentInstance(ICInstance inst, Ptr *component_inst)
  109. {
  110.     return (ICGetComponentInstance(inst, component_inst));
  111. }
  112.  
  113. /* ･･･Start PPC_ICAPI.c･･･ */
  114.  
  115. /* ***** Starting Up and Shutting Down ***** */
  116.  
  117. /* ***** Specifying a Configuration ***** */
  118.  
  119. pascal ICError ICFindConfigFile(ICInstance inst, short count, ICDirSpecArrayPtr folders)
  120. {
  121.   struct {
  122.     char param_flags;
  123.     char param_size;
  124.     short param_what;
  125.     ICDirSpecArrayPtr folders;
  126.     short count;
  127.     ICInstance inst;
  128.   } params;
  129.  
  130.   /* some setup */
  131.   params.param_flags = 0;
  132.   params.param_size = 6;
  133.   params.param_what = 2;
  134.   /* routine specific assignments */
  135.   params.folders = folders;
  136.   params.count = count;
  137.   /* do the work */
  138.   params.inst = inst;
  139.   return(CallUniversalProc(CallComponentUPP,
  140.     uppCallComponentProcInfo,
  141.     ¶ms));
  142. } /* ICFindConfigFile */
  143.  
  144. pascal ICError ICCFindConfigFile(ICInstance inst, short count, ICDirSpecArrayPtr folders)
  145. {
  146.   return(ICFindConfigFile(inst, count, folders));
  147. } /* ICCFindConfigFile */
  148.  
  149. pascal ICError ICFindUserConfigFile(ICInstance inst, ICDirSpec *where)
  150. {
  151.   struct {
  152.     char param_flags;
  153.     char param_size;
  154.     short param_what;
  155.     ICDirSpec *where;
  156.     ICInstance inst;
  157.   } params;
  158.  
  159.   /* some setup */
  160.   params.param_flags = 0;
  161.   params.param_size = 4;
  162.   params.param_what = 14;
  163.   /* routine specific assignments */
  164.   params.where = where;
  165.   /* do the work */
  166.   params.inst = inst;
  167.   return(CallUniversalProc(CallComponentUPP,
  168.     uppCallComponentProcInfo,
  169.     ¶ms));
  170. } /* ICFindUserConfigFile */
  171.  
  172. pascal ICError ICCFindUserConfigFile(ICInstance inst, ICDirSpec *where)
  173. {
  174.   return(ICFindUserConfigFile(inst, where));
  175. } /* ICCFindUserConfigFile */
  176.  
  177. pascal ICError ICGeneralFindConfigFile(ICInstance inst, Boolean search_prefs, Boolean can_create, short count, ICDirSpecArrayPtr folders)
  178. {
  179.   struct {
  180.     char param_flags;
  181.     char param_size;
  182.     short param_what;
  183.     ICDirSpecArrayPtr folders;
  184.     short count;
  185.     Boolean can_create;
  186.     char filler1;
  187.     Boolean search_prefs;
  188.     char filler0;
  189.     ICInstance inst;
  190.   } params;
  191.  
  192.   /* some setup */
  193.   params.param_flags = 0;
  194.   params.param_size = 10;
  195.   params.param_what = 30;
  196.   /* routine specific assignments */
  197.   params.folders = folders;
  198.   params.count = count;
  199.   params.can_create = can_create;
  200.   params.search_prefs = search_prefs;
  201.   /* do the work */
  202.   params.inst = inst;
  203.   return(CallUniversalProc(CallComponentUPP,
  204.     uppCallComponentProcInfo,
  205.     ¶ms));
  206. } /* ICGeneralFindConfigFile */
  207.  
  208. pascal ICError ICCGeneralFindConfigFile(ICInstance inst, Boolean search_prefs, Boolean can_create, short count, ICDirSpecArrayPtr folders)
  209. {
  210.   return(ICGeneralFindConfigFile(inst, search_prefs, can_create, count, folders));
  211. } /* ICCGeneralFindConfigFile */
  212.  
  213. pascal ICError ICChooseConfig(ICInstance inst)
  214. {
  215.   struct {
  216.     char param_flags;
  217.     char param_size;
  218.     short param_what;
  219.     /* nothing to declare */
  220.     ICInstance inst;
  221.   } params;
  222.  
  223.   /* some setup */
  224.   params.param_flags = 0;
  225.   params.param_size = 0;
  226.   params.param_what = 33;
  227.   /* routine specific assignments */
  228.   /* nothing to do */
  229.   /* do the work */
  230.   params.inst = inst;
  231.   return(CallUniversalProc(CallComponentUPP,
  232.     uppCallComponentProcInfo,
  233.     ¶ms));
  234. } /* ICChooseConfig */
  235.  
  236. pascal ICError ICCChooseConfig(ICInstance inst)
  237. {
  238.   return(ICChooseConfig(inst));
  239. } /* ICCChooseConfig */
  240.  
  241. pascal ICError ICChooseNewConfig(ICInstance inst)
  242. {
  243.   struct {
  244.     char param_flags;
  245.     char param_size;
  246.     short param_what;
  247.     /* nothing to declare */
  248.     ICInstance inst;
  249.   } params;
  250.  
  251.   /* some setup */
  252.   params.param_flags = 0;
  253.   params.param_size = 0;
  254.   params.param_what = 34;
  255.   /* routine specific assignments */
  256.   /* nothing to do */
  257.   /* do the work */
  258.   params.inst = inst;
  259.   return(CallUniversalProc(CallComponentUPP,
  260.     uppCallComponentProcInfo,
  261.     ¶ms));
  262. } /* ICChooseNewConfig */
  263.  
  264. pascal ICError ICCChooseNewConfig(ICInstance inst)
  265. {
  266.   return(ICChooseNewConfig(inst));
  267. } /* ICCChooseNewConfig */
  268.  
  269. pascal ICError ICGetConfigName(ICInstance inst, Boolean longname, Str255 name)
  270. {
  271.   struct {
  272.     char param_flags;
  273.     char param_size;
  274.     short param_what;
  275.     StringPtr name;
  276.     Boolean longname;
  277.     char filler0;
  278.     ICInstance inst;
  279.   } params;
  280.  
  281.   /* some setup */
  282.   params.param_flags = 0;
  283.   params.param_size = 6;
  284.   params.param_what = 35;
  285.   /* routine specific assignments */
  286.   params.name = name;
  287.   params.longname = longname;
  288.   /* do the work */
  289.   params.inst = inst;
  290.   return(CallUniversalProc(CallComponentUPP,
  291.     uppCallComponentProcInfo,
  292.     ¶ms));
  293. } /* ICGetConfigName */
  294.  
  295. pascal ICError ICCGetConfigName(ICInstance inst, Boolean longname, Str255 name)
  296. {
  297.   return(ICGetConfigName(inst, longname, name));
  298. } /* ICCGetConfigName */
  299.  
  300. pascal ICError ICGetConfigReference(ICInstance inst, ICConfigRefHandle ref)
  301. {
  302.   struct {
  303.     char param_flags;
  304.     char param_size;
  305.     short param_what;
  306.     ICConfigRefHandle ref;
  307.     ICInstance inst;
  308.   } params;
  309.  
  310.   /* some setup */
  311.   params.param_flags = 0;
  312.   params.param_size = 4;
  313.   params.param_what = 31;
  314.   /* routine specific assignments */
  315.   params.ref = ref;
  316.   /* do the work */
  317.   params.inst = inst;
  318.   return(CallUniversalProc(CallComponentUPP,
  319.     uppCallComponentProcInfo,
  320.     ¶ms));
  321. } /* ICGetConfigReference */
  322.  
  323. pascal ICError ICCGetConfigReference(ICInstance inst, ICConfigRefHandle ref)
  324. {
  325.   return(ICGetConfigReference(inst, ref));
  326. } /* ICCGetConfigReference */
  327.  
  328. pascal ICError ICSetConfigReference(ICInstance inst, ICConfigRefHandle ref, long flags)
  329. {
  330.   struct {
  331.     char param_flags;
  332.     char param_size;
  333.     short param_what;
  334.     long flags;
  335.     ICConfigRefHandle ref;
  336.     ICInstance inst;
  337.   } params;
  338.  
  339.   /* some setup */
  340.   params.param_flags = 0;
  341.   params.param_size = 8;
  342.   params.param_what = 32;
  343.   /* routine specific assignments */
  344.   params.flags = flags;
  345.   params.ref = ref;
  346.   /* do the work */
  347.   params.inst = inst;
  348.   return(CallUniversalProc(CallComponentUPP,
  349.     uppCallComponentProcInfo,
  350.     ¶ms));
  351. } /* ICSetConfigReference */
  352.  
  353. pascal ICError ICCSetConfigReference(ICInstance inst, ICConfigRefHandle ref, long flags)
  354. {
  355.   return(ICSetConfigReference(inst, ref, flags));
  356. } /* ICCSetConfigReference */
  357.  
  358. pascal ICError ICSpecifyConfigFile(ICInstance inst, FSSpec *config)
  359. {
  360.   struct {
  361.     char param_flags;
  362.     char param_size;
  363.     short param_what;
  364.     FSSpec *config;
  365.     ICInstance inst;
  366.   } params;
  367.  
  368.   /* some setup */
  369.   params.param_flags = 0;
  370.   params.param_size = 4;
  371.   params.param_what = 3;
  372.   /* routine specific assignments */
  373.   params.config = config;
  374.   /* do the work */
  375.   params.inst = inst;
  376.   return(CallUniversalProc(CallComponentUPP,
  377.     uppCallComponentProcInfo,
  378.     ¶ms));
  379. } /* ICSpecifyConfigFile */
  380.  
  381. pascal ICError ICCSpecifyConfigFile(ICInstance inst, FSSpec *config)
  382. {
  383.   return(ICSpecifyConfigFile(inst, config));
  384. } /* ICCSpecifyConfigFile */
  385.  
  386. /* ***** Getting Information ***** */
  387.  
  388. pascal ICError ICGetSeed(ICInstance inst, long *seed)
  389. {
  390.   struct {
  391.     char param_flags;
  392.     char param_size;
  393.     short param_what;
  394.     long *seed;
  395.     ICInstance inst;
  396.   } params;
  397.  
  398.   /* some setup */
  399.   params.param_flags = 0;
  400.   params.param_size = 4;
  401.   params.param_what = 4;
  402.   /* routine specific assignments */
  403.   params.seed = seed;
  404.   /* do the work */
  405.   params.inst = inst;
  406.   return(CallUniversalProc(CallComponentUPP,
  407.     uppCallComponentProcInfo,
  408.     ¶ms));
  409. } /* ICGetSeed */
  410.  
  411. pascal ICError ICCGetSeed(ICInstance inst, long *seed)
  412. {
  413.   return(ICGetSeed(inst, seed));
  414. } /* ICCGetSeed */
  415.  
  416. pascal ICError ICGetPerm(ICInstance inst, ICPerm *perm)
  417. {
  418.   struct {
  419.     char param_flags;
  420.     char param_size;
  421.     short param_what;
  422.     ICPerm *perm;
  423.     ICInstance inst;
  424.   } params;
  425.  
  426.   /* some setup */
  427.   params.param_flags = 0;
  428.   params.param_size = 4;
  429.   params.param_what = 13;
  430.   /* routine specific assignments */
  431.   params.perm = perm;
  432.   /* do the work */
  433.   params.inst = inst;
  434.   return(CallUniversalProc(CallComponentUPP,
  435.     uppCallComponentProcInfo,
  436.     ¶ms));
  437. } /* ICGetPerm */
  438.  
  439. pascal ICError ICCGetPerm(ICInstance inst, ICPerm *perm)
  440. {
  441.   return(ICGetPerm(inst, perm));
  442. } /* ICCGetPerm */
  443.  
  444. pascal ICError ICDefaultFileName(ICInstance inst, Str63 name)
  445. {
  446.   struct {
  447.     char param_flags;
  448.     char param_size;
  449.     short param_what;
  450.     StringPtr name;
  451.     ICInstance inst;
  452.   } params;
  453.  
  454.   /* some setup */
  455.   params.param_flags = 0;
  456.   params.param_size = 4;
  457.   params.param_what = 11;
  458.   /* routine specific assignments */
  459.   params.name = name;
  460.   /* do the work */
  461.   params.inst = inst;
  462.   return(CallUniversalProc(CallComponentUPP,
  463.     uppCallComponentProcInfo,
  464.     ¶ms));
  465. } /* ICDefaultFileName */
  466.  
  467. pascal ICError ICCDefaultFileName(ICInstance inst, Str63 name)
  468. {
  469.   return(ICDefaultFileName(inst, name));
  470. } /* ICCDefaultFileName */
  471.  
  472. /* ***** Reading and Writing Preferences ***** */
  473.  
  474. pascal ICError ICBegin(ICInstance inst, ICPerm perm)
  475. {
  476.   struct {
  477.     char param_flags;
  478.     char param_size;
  479.     short param_what;
  480.     ICPerm perm;
  481.     ICInstance inst;
  482.   } params;
  483.  
  484.   /* some setup */
  485.   params.param_flags = 0;
  486.   params.param_size = 2;
  487.   params.param_what = 5;
  488.   /* routine specific assignments */
  489.   params.perm = perm;
  490.   /* do the work */
  491.   params.inst = inst;
  492.   return(CallUniversalProc(CallComponentUPP,
  493.     uppCallComponentProcInfo,
  494.     ¶ms));
  495. } /* ICBegin */
  496.  
  497. pascal ICError ICCBegin(ICInstance inst, ICPerm perm)
  498. {
  499.   return(ICBegin(inst, perm));
  500. } /* ICCBegin */
  501.  
  502. pascal ICError ICGetPref(ICInstance inst, ConstStr255Param key, ICAttr *attr, Ptr buf, long *size)
  503. {
  504.   struct {
  505.     char param_flags;
  506.     char param_size;
  507.     short param_what;
  508.     long *size;
  509.     Ptr buf;
  510.     ICAttr *attr;
  511.     StringPtr key;
  512.     ICInstance inst;
  513.   } params;
  514.  
  515.   /* some setup */
  516.   params.param_flags = 0;
  517.   params.param_size = 16;
  518.   params.param_what = 6;
  519.   /* routine specific assignments */
  520.   params.size = size;
  521.   params.buf = buf;
  522.   params.attr = attr;
  523.   params.key = (StringPtr) key;
  524.   /* do the work */
  525.   params.inst = inst;
  526.   return(CallUniversalProc(CallComponentUPP,
  527.     uppCallComponentProcInfo,
  528.     ¶ms));
  529. } /* ICGetPref */
  530.  
  531. pascal ICError ICCGetPref(ICInstance inst, ConstStr255Param key, ICAttr *attr, Ptr buf, long *size)
  532. {
  533.   return(ICGetPref(inst, key, attr, buf, size));
  534. } /* ICCGetPref */
  535.  
  536. pascal ICError ICSetPref(ICInstance inst, ConstStr255Param key, ICAttr attr, Ptr buf, long size)
  537. {
  538.   struct {
  539.     char param_flags;
  540.     char param_size;
  541.     short param_what;
  542.     long size;
  543.     Ptr buf;
  544.     ICAttr attr;
  545.     StringPtr key;
  546.     ICInstance inst;
  547.   } params;
  548.  
  549.   /* some setup */
  550.   params.param_flags = 0;
  551.   params.param_size = 16;
  552.   params.param_what = 7;
  553.   /* routine specific assignments */
  554.   params.size = size;
  555.   params.buf = buf;
  556.   params.attr = attr;
  557.   params.key = (StringPtr) key;
  558.   /* do the work */
  559.   params.inst = inst;
  560.   return(CallUniversalProc(CallComponentUPP,
  561.     uppCallComponentProcInfo,
  562.     ¶ms));
  563. } /* ICSetPref */
  564.  
  565. pascal ICError ICCSetPref(ICInstance inst, ConstStr255Param key, ICAttr attr, Ptr buf, long size)
  566. {
  567.   return(ICSetPref(inst, key, attr, buf, size));
  568. } /* ICCSetPref */
  569.  
  570. pascal ICError ICFindPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr *attr, Handle prefh)
  571. {
  572.   struct {
  573.     char param_flags;
  574.     char param_size;
  575.     short param_what;
  576.     Handle prefh;
  577.     ICAttr *attr;
  578.     StringPtr key;
  579.     ICInstance inst;
  580.   } params;
  581.  
  582.   /* some setup */
  583.   params.param_flags = 0;
  584.   params.param_size = 12;
  585.   params.param_what = 36;
  586.   /* routine specific assignments */
  587.   params.prefh = prefh;
  588.   params.attr = attr;
  589.   params.key = (StringPtr) key;
  590.   /* do the work */
  591.   params.inst = inst;
  592.   return(CallUniversalProc(CallComponentUPP,
  593.     uppCallComponentProcInfo,
  594.     ¶ms));
  595. } /* ICFindPrefHandle */
  596.  
  597. pascal ICError ICCFindPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr *attr, Handle prefh)
  598. {
  599.   return(ICFindPrefHandle(inst, key, attr, prefh));
  600. } /* ICCFindPrefHandle */
  601.  
  602. pascal ICError ICGetPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr *attr, Handle *prefh)
  603. {
  604.   struct {
  605.     char param_flags;
  606.     char param_size;
  607.     short param_what;
  608.     Handle *prefh;
  609.     ICAttr *attr;
  610.     StringPtr key;
  611.     ICInstance inst;
  612.   } params;
  613.  
  614.   /* some setup */
  615.   params.param_flags = 0;
  616.   params.param_size = 12;
  617.   params.param_what = 26;
  618.   /* routine specific assignments */
  619.   params.prefh = prefh;
  620.   params.attr = attr;
  621.   params.key = (StringPtr) key;
  622.   /* do the work */
  623.   params.inst = inst;
  624.   return(CallUniversalProc(CallComponentUPP,
  625.     uppCallComponentProcInfo,
  626.     ¶ms));
  627. } /* ICGetPrefHandle */
  628.  
  629. pascal ICError ICCGetPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr *attr, Handle *prefh)
  630. {
  631.   return(ICGetPrefHandle(inst, key, attr, prefh));
  632. } /* ICCGetPrefHandle */
  633.  
  634. pascal ICError ICSetPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr attr, Handle prefh)
  635. {
  636.   struct {
  637.     char param_flags;
  638.     char param_size;
  639.     short param_what;
  640.     Handle prefh;
  641.     ICAttr attr;
  642.     StringPtr key;
  643.     ICInstance inst;
  644.   } params;
  645.  
  646.   /* some setup */
  647.   params.param_flags = 0;
  648.   params.param_size = 12;
  649.   params.param_what = 27;
  650.   /* routine specific assignments */
  651.   params.prefh = prefh;
  652.   params.attr = attr;
  653.   params.key = (StringPtr) key;
  654.   /* do the work */
  655.   params.inst = inst;
  656.   return(CallUniversalProc(CallComponentUPP,
  657.     uppCallComponentProcInfo,
  658.     ¶ms));
  659. } /* ICSetPrefHandle */
  660.  
  661. pascal ICError ICCSetPrefHandle(ICInstance inst, ConstStr255Param key, ICAttr attr, Handle prefh)
  662. {
  663.   return(ICSetPrefHandle(inst, key, attr, prefh));
  664. } /* ICCSetPrefHandle */
  665.  
  666. pascal ICError ICCountPref(ICInstance inst, long *count)
  667. {
  668.   struct {
  669.     char param_flags;
  670.     char param_size;
  671.     short param_what;
  672.     long *count;
  673.     ICInstance inst;
  674.   } params;
  675.  
  676.   /* some setup */
  677.   params.param_flags = 0;
  678.   params.param_size = 4;
  679.   params.param_what = 8;
  680.   /* routine specific assignments */
  681.   params.count = count;
  682.   /* do the work */
  683.   params.inst = inst;
  684.   return(CallUniversalProc(CallComponentUPP,
  685.     uppCallComponentProcInfo,
  686.     ¶ms));
  687. } /* ICCountPref */
  688.  
  689. pascal ICError ICCCountPref(ICInstance inst, long *count)
  690. {
  691.   return(ICCountPref(inst, count));
  692. } /* ICCCountPref */
  693.  
  694. pascal ICError ICGetIndPref(ICInstance inst, long n, Str255 key)
  695. {
  696.   struct {
  697.     char param_flags;
  698.     char param_size;
  699.     short param_what;
  700.     StringPtr key;
  701.     long n;
  702.     ICInstance inst;
  703.   } params;
  704.  
  705.   /* some setup */
  706.   params.param_flags = 0;
  707.   params.param_size = 8;
  708.   params.param_what = 9;
  709.   /* routine specific assignments */
  710.   params.key = key;
  711.   params.n = n;
  712.   /* do the work */
  713.   params.inst = inst;
  714.   return(CallUniversalProc(CallComponentUPP,
  715.     uppCallComponentProcInfo,
  716.     ¶ms));
  717. } /* ICGetIndPref */
  718.  
  719. pascal ICError ICCGetIndPref(ICInstance inst, long n, Str255 key)
  720. {
  721.   return(ICGetIndPref(inst, n, key));
  722. } /* ICCGetIndPref */
  723.  
  724. pascal ICError ICDeletePref(ICInstance inst, ConstStr255Param key)
  725. {
  726.   struct {
  727.     char param_flags;
  728.     char param_size;
  729.     short param_what;
  730.     StringPtr key;
  731.     ICInstance inst;
  732.   } params;
  733.  
  734.   /* some setup */
  735.   params.param_flags = 0;
  736.   params.param_size = 4;
  737.   params.param_what = 12;
  738.   /* routine specific assignments */
  739.   params.key = (StringPtr) key;
  740.   /* do the work */
  741.   params.inst = inst;
  742.   return(CallUniversalProc(CallComponentUPP,
  743.     uppCallComponentProcInfo,
  744.     ¶ms));
  745. } /* ICDeletePref */
  746.  
  747. pascal ICError ICCDeletePref(ICInstance inst, ConstStr255Param key)
  748. {
  749.   return(ICDeletePref(inst, key));
  750. } /* ICCDeletePref */
  751.  
  752. pascal ICError ICEnd(ICInstance inst)
  753. {
  754.   struct {
  755.     char param_flags;
  756.     char param_size;
  757.     short param_what;
  758.     /* nothing to declare */
  759.     ICInstance inst;
  760.   } params;
  761.  
  762.   /* some setup */
  763.   params.param_flags = 0;
  764.   params.param_size = 0;
  765.   params.param_what = 10;
  766.   /* routine specific assignments */
  767.   /* nothing to do */
  768.   /* do the work */
  769.   params.inst = inst;
  770.   return(CallUniversalProc(CallComponentUPP,
  771.     uppCallComponentProcInfo,
  772.     ¶ms));
  773. } /* ICEnd */
  774.  
  775. pascal ICError ICCEnd(ICInstance inst)
  776. {
  777.   return(ICEnd(inst));
  778. } /* ICCEnd */
  779.  
  780. /* ***** User Interface Stuff ***** */
  781.  
  782. pascal ICError ICEditPreferences(ICInstance inst, ConstStr255Param key)
  783. {
  784.   struct {
  785.     char param_flags;
  786.     char param_size;
  787.     short param_what;
  788.     StringPtr key;
  789.     ICInstance inst;
  790.   } params;
  791.  
  792.   /* some setup */
  793.   params.param_flags = 0;
  794.   params.param_size = 4;
  795.   params.param_what = 15;
  796.   /* routine specific assignments */
  797.   params.key = (StringPtr) key;
  798.   /* do the work */
  799.   params.inst = inst;
  800.   return(CallUniversalProc(CallComponentUPP,
  801.     uppCallComponentProcInfo,
  802.     ¶ms));
  803. } /* ICEditPreferences */
  804.  
  805. pascal ICError ICCEditPreferences(ICInstance inst, ConstStr255Param key)
  806. {
  807.   return(ICEditPreferences(inst, key));
  808. } /* ICCEditPreferences */
  809.  
  810. /* ***** URL Handling ***** */
  811.  
  812. pascal ICError ICParseURL(ICInstance inst, ConstStr255Param hint, Ptr data, long len, long *selStart, long *selEnd, Handle url)
  813. {
  814.   struct {
  815.     char param_flags;
  816.     char param_size;
  817.     short param_what;
  818.     Handle url;
  819.     long *selEnd;
  820.     long *selStart;
  821.     long len;
  822.     Ptr data;
  823.     StringPtr hint;
  824.     ICInstance inst;
  825.   } params;
  826.  
  827.   /* some setup */
  828.   params.param_flags = 0;
  829.   params.param_size = 24;
  830.   params.param_what = 16;
  831.   /* routine specific assignments */
  832.   params.url = url;
  833.   params.selEnd = selEnd;
  834.   params.selStart = selStart;
  835.   params.len = len;
  836.   params.data = data;
  837.   params.hint = (StringPtr) hint;
  838.   /* do the work */
  839.   params.inst = inst;
  840.   return(CallUniversalProc(CallComponentUPP,
  841.     uppCallComponentProcInfo,
  842.     ¶ms));
  843. } /* ICParseURL */
  844.  
  845. pascal ICError ICCParseURL(ICInstance inst, ConstStr255Param hint, Ptr data, long len, long *selStart, long *selEnd, Handle url)
  846. {
  847.   return(ICParseURL(inst, hint, data, len, selStart, selEnd, url));
  848. } /* ICCParseURL */
  849.  
  850. pascal ICError ICLaunchURL(ICInstance inst, ConstStr255Param hint, Ptr data, long len, long *selStart, long *selEnd)
  851. {
  852.   struct {
  853.     char param_flags;
  854.     char param_size;
  855.     short param_what;
  856.     long *selEnd;
  857.     long *selStart;
  858.     long len;
  859.     Ptr data;
  860.     StringPtr hint;
  861.     ICInstance inst;
  862.   } params;
  863.  
  864.   /* some setup */
  865.   params.param_flags = 0;
  866.   params.param_size = 20;
  867.   params.param_what = 17;
  868.   /* routine specific assignments */
  869.   params.selEnd = selEnd;
  870.   params.selStart = selStart;
  871.   params.len = len;
  872.   params.data = data;
  873.   params.hint = (StringPtr) hint;
  874.   /* do the work */
  875.   params.inst = inst;
  876.   return(CallUniversalProc(CallComponentUPP,
  877.     uppCallComponentProcInfo,
  878.     ¶ms));
  879. } /* ICLaunchURL */
  880.  
  881. pascal ICError ICCLaunchURL(ICInstance inst, ConstStr255Param hint, Ptr data, long len, long *selStart, long *selEnd)
  882. {
  883.   return(ICLaunchURL(inst, hint, data, len, selStart, selEnd));
  884. } /* ICCLaunchURL */
  885.  
  886. /* ***** Mappings Routines *****
  887.  * 
  888.  * Routines for interrogating mappings database.
  889.  * 
  890.  * ----- High Level Routines -----
  891.  */
  892.  
  893. pascal ICError ICMapFilename(ICInstance inst, ConstStr255Param filename, ICMapEntry *entry)
  894. {
  895.   struct {
  896.     char param_flags;
  897.     char param_size;
  898.     short param_what;
  899.     ICMapEntry *entry;
  900.     StringPtr filename;
  901.     ICInstance inst;
  902.   } params;
  903.  
  904.   /* some setup */
  905.   params.param_flags = 0;
  906.   params.param_size = 8;
  907.   params.param_what = 24;
  908.   /* routine specific assignments */
  909.   params.entry = entry;
  910.   params.filename = (StringPtr) filename;
  911.   /* do the work */
  912.   params.inst = inst;
  913.   return(CallUniversalProc(CallComponentUPP,
  914.     uppCallComponentProcInfo,
  915.     ¶ms));
  916. } /* ICMapFilename */
  917.  
  918. pascal ICError ICCMapFilename(ICInstance inst, ConstStr255Param filename, ICMapEntry *entry)
  919. {
  920.   return(ICMapFilename(inst, filename, entry));
  921. } /* ICCMapFilename */
  922.  
  923. pascal ICError ICMapTypeCreator(ICInstance inst, OSType fType, OSType fCreator, ConstStr255Param filename, ICMapEntry *entry)
  924. {
  925.   struct {
  926.     char param_flags;
  927.     char param_size;
  928.     short param_what;
  929.     ICMapEntry *entry;
  930.     StringPtr filename;
  931.     OSType fCreator;
  932.     OSType fType;
  933.     ICInstance inst;
  934.   } params;
  935.  
  936.   /* some setup */
  937.   params.param_flags = 0;
  938.   params.param_size = 16;
  939.   params.param_what = 25;
  940.   /* routine specific assignments */
  941.   params.entry = entry;
  942.   params.filename = (StringPtr) filename;
  943.   params.fCreator = fCreator;
  944.   params.fType = fType;
  945.   /* do the work */
  946.   params.inst = inst;
  947.   return(CallUniversalProc(CallComponentUPP,
  948.     uppCallComponentProcInfo,
  949.     ¶ms));
  950. } /* ICMapTypeCreator */
  951.  
  952. pascal ICError ICCMapTypeCreator(ICInstance inst, OSType fType, OSType fCreator, ConstStr255Param filename, ICMapEntry *entry)
  953. {
  954.   return(ICMapTypeCreator(inst, fType, fCreator, filename, entry));
  955. } /* ICCMapTypeCreator */
  956.  
  957. /* ----- Mid Level Routines ----- */
  958.  
  959. pascal ICError ICMapEntriesFilename(ICInstance inst, Handle entries, ConstStr255Param filename, ICMapEntry *entry)
  960. {
  961.   struct {
  962.     char param_flags;
  963.     char param_size;
  964.     short param_what;
  965.     ICMapEntry *entry;
  966.     StringPtr filename;
  967.     Handle entries;
  968.     ICInstance inst;
  969.   } params;
  970.  
  971.   /* some setup */
  972.   params.param_flags = 0;
  973.   params.param_size = 12;
  974.   params.param_what = 28;
  975.   /* routine specific assignments */
  976.   params.entry = entry;
  977.   params.filename = (StringPtr) filename;
  978.   params.entries = entries;
  979.   /* do the work */
  980.   params.inst = inst;
  981.   return(CallUniversalProc(CallComponentUPP,
  982.     uppCallComponentProcInfo,
  983.     ¶ms));
  984. } /* ICMapEntriesFilename */
  985.  
  986. pascal ICError ICCMapEntriesFilename(ICInstance inst, Handle entries, ConstStr255Param filename, ICMapEntry *entry)
  987. {
  988.   return(ICMapEntriesFilename(inst, entries, filename, entry));
  989. } /* ICCMapEntriesFilename */
  990.  
  991. pascal ICError ICMapEntriesTypeCreator(ICInstance inst, Handle entries, OSType fType, OSType fCreator, ConstStr255Param filename, ICMapEntry *entry)
  992. {
  993.   struct {
  994.     char param_flags;
  995.     char param_size;
  996.     short param_what;
  997.     ICMapEntry *entry;
  998.     StringPtr filename;
  999.     OSType fCreator;
  1000.     OSType fType;
  1001.     Handle entries;
  1002.     ICInstance inst;
  1003.   } params;
  1004.  
  1005.   /* some setup */
  1006.   params.param_flags = 0;
  1007.   params.param_size = 20;
  1008.   params.param_what = 29;
  1009.   /* routine specific assignments */
  1010.   params.entry = entry;
  1011.   params.filename = (StringPtr) filename;
  1012.   params.fCreator = fCreator;
  1013.   params.fType = fType;
  1014.   params.entries = entries;
  1015.   /* do the work */
  1016.   params.inst = inst;
  1017.   return(CallUniversalProc(CallComponentUPP,
  1018.     uppCallComponentProcInfo,
  1019.     ¶ms));
  1020. } /* ICMapEntriesTypeCreator */
  1021.  
  1022. pascal ICError ICCMapEntriesTypeCreator(ICInstance inst, Handle entries, OSType fType, OSType fCreator, ConstStr255Param filename, ICMapEntry *entry)
  1023. {
  1024.   return(ICMapEntriesTypeCreator(inst, entries, fType, fCreator, filename, entry));
  1025. } /* ICCMapEntriesTypeCreator */
  1026.  
  1027. /* ----- Low Level Routines ----- */
  1028.  
  1029. pascal ICError ICCountMapEntries(ICInstance inst, Handle entries, long *count)
  1030. {
  1031.   struct {
  1032.     char param_flags;
  1033.     char param_size;
  1034.     short param_what;
  1035.     long *count;
  1036.     Handle entries;
  1037.     ICInstance inst;
  1038.   } params;
  1039.  
  1040.   /* some setup */
  1041.   params.param_flags = 0;
  1042.   params.param_size = 8;
  1043.   params.param_what = 18;
  1044.   /* routine specific assignments */
  1045.   params.count = count;
  1046.   params.entries = entries;
  1047.   /* do the work */
  1048.   params.inst = inst;
  1049.   return(CallUniversalProc(CallComponentUPP,
  1050.     uppCallComponentProcInfo,
  1051.     ¶ms));
  1052. } /* ICCountMapEntries */
  1053.  
  1054. pascal ICError ICCCountMapEntries(ICInstance inst, Handle entries, long *count)
  1055. {
  1056.   return(ICCountMapEntries(inst, entries, count));
  1057. } /* ICCCountMapEntries */
  1058.  
  1059. pascal ICError ICGetIndMapEntry(ICInstance inst, Handle entries, long ndx, long *pos, ICMapEntry *entry)
  1060. {
  1061.   struct {
  1062.     char param_flags;
  1063.     char param_size;
  1064.     short param_what;
  1065.     ICMapEntry *entry;
  1066.     long *pos;
  1067.     long ndx;
  1068.     Handle entries;
  1069.     ICInstance inst;
  1070.   } params;
  1071.  
  1072.   /* some setup */
  1073.   params.param_flags = 0;
  1074.   params.param_size = 16;
  1075.   params.param_what = 19;
  1076.   /* routine specific assignments */
  1077.   params.entry = entry;
  1078.   params.pos = pos;
  1079.   params.ndx = ndx;
  1080.   params.entries = entries;
  1081.   /* do the work */
  1082.   params.inst = inst;
  1083.   return(CallUniversalProc(CallComponentUPP,
  1084.     uppCallComponentProcInfo,
  1085.     ¶ms));
  1086. } /* ICGetIndMapEntry */
  1087.  
  1088. pascal ICError ICCGetIndMapEntry(ICInstance inst, Handle entries, long ndx, long *pos, ICMapEntry *entry)
  1089. {
  1090.   return(ICGetIndMapEntry(inst, entries, ndx, pos, entry));
  1091. } /* ICCGetIndMapEntry */
  1092.  
  1093. pascal ICError ICGetMapEntry(ICInstance inst, Handle entries, long pos, ICMapEntry *entry)
  1094. {
  1095.   struct {
  1096.     char param_flags;
  1097.     char param_size;
  1098.     short param_what;
  1099.     ICMapEntry *entry;
  1100.     long pos;
  1101.     Handle entries;
  1102.     ICInstance inst;
  1103.   } params;
  1104.  
  1105.   /* some setup */
  1106.   params.param_flags = 0;
  1107.   params.param_size = 12;
  1108.   params.param_what = 20;
  1109.   /* routine specific assignments */
  1110.   params.entry = entry;
  1111.   params.pos = pos;
  1112.   params.entries = entries;
  1113.   /* do the work */
  1114.   params.inst = inst;
  1115.   return(CallUniversalProc(CallComponentUPP,
  1116.     uppCallComponentProcInfo,
  1117.     ¶ms));
  1118. } /* ICGetMapEntry */
  1119.  
  1120. pascal ICError ICCGetMapEntry(ICInstance inst, Handle entries, long pos, ICMapEntry *entry)
  1121. {
  1122.   return(ICGetMapEntry(inst, entries, pos, entry));
  1123. } /* ICCGetMapEntry */
  1124.  
  1125. pascal ICError ICSetMapEntry(ICInstance inst, Handle entries, long pos, ICMapEntry *entry)
  1126. {
  1127.   struct {
  1128.     char param_flags;
  1129.     char param_size;
  1130.     short param_what;
  1131.     ICMapEntry *entry;
  1132.     long pos;
  1133.     Handle entries;
  1134.     ICInstance inst;
  1135.   } params;
  1136.  
  1137.   /* some setup */
  1138.   params.param_flags = 0;
  1139.   params.param_size = 12;
  1140.   params.param_what = 21;
  1141.   /* routine specific assignments */
  1142.   params.entry = entry;
  1143.   params.pos = pos;
  1144.   params.entries = entries;
  1145.   /* do the work */
  1146.   params.inst = inst;
  1147.   return(CallUniversalProc(CallComponentUPP,
  1148.     uppCallComponentProcInfo,
  1149.     ¶ms));
  1150. } /* ICSetMapEntry */
  1151.  
  1152. pascal ICError ICCSetMapEntry(ICInstance inst, Handle entries, long pos, ICMapEntry *entry)
  1153. {
  1154.   return(ICSetMapEntry(inst, entries, pos, entry));
  1155. } /* ICCSetMapEntry */
  1156.  
  1157. pascal ICError ICDeleteMapEntry(ICInstance inst, Handle entries, long pos)
  1158. {
  1159.   struct {
  1160.     char param_flags;
  1161.     char param_size;
  1162.     short param_what;
  1163.     long pos;
  1164.     Handle entries;
  1165.     ICInstance inst;
  1166.   } params;
  1167.  
  1168.   /* some setup */
  1169.   params.param_flags = 0;
  1170.   params.param_size = 8;
  1171.   params.param_what = 22;
  1172.   /* routine specific assignments */
  1173.   params.pos = pos;
  1174.   params.entries = entries;
  1175.   /* do the work */
  1176.   params.inst = inst;
  1177.   return(CallUniversalProc(CallComponentUPP,
  1178.     uppCallComponentProcInfo,
  1179.     ¶ms));
  1180. } /* ICDeleteMapEntry */
  1181.  
  1182. pascal ICError ICCDeleteMapEntry(ICInstance inst, Handle entries, long pos)
  1183. {
  1184.   return(ICDeleteMapEntry(inst, entries, pos));
  1185. } /* ICCDeleteMapEntry */
  1186.  
  1187. pascal ICError ICAddMapEntry(ICInstance inst, Handle entries, ICMapEntry *entry)
  1188. {
  1189.   struct {
  1190.     char param_flags;
  1191.     char param_size;
  1192.     short param_what;
  1193.     ICMapEntry *entry;
  1194.     Handle entries;
  1195.     ICInstance inst;
  1196.   } params;
  1197.  
  1198.   /* some setup */
  1199.   params.param_flags = 0;
  1200.   params.param_size = 8;
  1201.   params.param_what = 23;
  1202.   /* routine specific assignments */
  1203.   params.entry = entry;
  1204.   params.entries = entries;
  1205.   /* do the work */
  1206.   params.inst = inst;
  1207.   return(CallUniversalProc(CallComponentUPP,
  1208.     uppCallComponentProcInfo,
  1209.     ¶ms));
  1210. } /* ICAddMapEntry */
  1211.  
  1212. pascal ICError ICCAddMapEntry(ICInstance inst, Handle entries, ICMapEntry *entry)
  1213. {
  1214.   return(ICAddMapEntry(inst, entries, entry));
  1215. } /* ICCAddMapEntry */
  1216.  
  1217.  
  1218. /* ･･･End PPC_ICAPI.c･･･ */
  1219.  
  1220. /* End of File */
  1221.